数据结构-平衡二叉树之AVL树

最新推荐文章于 2022-09-09 22:57:00 发布
最新推荐文章于 2022-09-09 22:57:00 发布
阅读量296 收藏 1
点赞数
分类专栏： 数据结构与算法 数据结构与算法 文章标签： AVL树 平衡二叉树 二分搜索树 树 AVL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love905661433/article/details/83050070
版权

概述

二分搜索树 : https://blog.csdn.net/love905661433/article/details/82981527
针对普通的二分搜索树, 在最坏的情况下可能会退化成链表, 所以就引入了平衡二叉树的概念

平衡二叉树

  • 满二叉树一定是平衡二叉树
  • 完全二叉树也是平衡二叉树
  • 对于任意一个节点, 左子树和右子树的高度差不能超过1
  • 平衡二叉树的高度和节点数量之间的关系是O(logn)的关系

AVL树

  • 自平衡二叉树

  • 标注节点高度, 所有叶子节点高度都为1, 非叶子节点高度为左右孩子节点中高度较高的节点高度加一, 如下图所示
    1539400916021

  • 计算平衡因子, 即左右子树的高度差的绝对值, 如果存在节点的平衡因子大于1, 则表示这个树不是平衡二叉树了
    AVL树平衡因子
    AVL树Node节点代码如下 :

	/**
	 * 二分搜索树节点类
	 * 这个AVL树是保存<key, value>映射的, 所有使用key, value两个变量
	 * @author 七夜雪
	 *
	 */
	private class Node {
		public K key ;
		public V value;
		// 左右子树
		public Node	left , right ;
        // 节点高度
		public int height;
		
		public Node(K key, V value) {
			this.key = key ;
			this.value = value ;
			// 叶子节点高度默认为1
			this.height = 1;
			this.left = null ;
			this.right = null ;
		}
	}

自平衡操作

  • 维护平衡的操作在插入之后进行维护, 沿着节点向上维护平衡性, 如下图所示 :
    在这里插入图片描述
  • 删除操作在针对二分搜索树完成节点删除之后的平衡维护操作和插入节点的平衡维护操作是一致的
    AVL树存在下面四种失去平衡的情况, 如下图所示 :

在这里插入图片描述

  1. 插入节点在不平衡节点的左侧的左侧(LL), 需要对y节点进行右旋转操作
  2. 插入节点在不平衡节点的右侧的右侧(RR), 需要对y节点进行左旋转操作
  3. 插入节点在不平衡节点的左侧的右侧(LR), 需要先对x节点进行左旋转操作, 转换成LL的情况, 再对y节点进行右旋转操作
  4. 插入节点在不平衡节点的右侧的左侧(RL), 需要先对x节点进行右旋转操作, 转换成RR的情况, 再对y节点进行左旋转操作

插入的元素在不平衡节点的左侧的左侧(LL)

  • LL的情况需要进行右旋转
  • 左侧的树插入节点5之后, 向上追溯, 在节点12处, 平衡因子>1,破坏了AVL树的平衡性, 所以需要维护节点12的平衡性
  • 右侧的树在插入节点2之后, 从节点2向上追溯, 在节点8处, 平衡因子>1, 破坏了AVL树的平衡性, 所以需要维护节点8的平衡性
    在这里插入图片描述

对于上述情况, 需要通过右旋转进行平衡性维护, 具体操作步骤如下 :

  1. 对于上面两种情况, 抽象成下图, 对于下图, 存在如下关系 : T1 < z < T2 < x < T3 < y < T4
  2. 首先将x节点的右孩子指向y节点
  3. 将y节点的左孩子指向T3节点, 这就完成了右旋转操作, 而且并没有破坏二分搜索树的特性
    在这里插入图片描述

右旋转操作代码 :

	/**
	 * 对y节点进行右旋转操作
	 *          y                                  x
     *         / \                               /   \
     *       x   T4     向右旋转 (y)            z      y
     *      / \       - - - - - - - ->        / \    /  \
     *     z   T3                            T1  T2 T3  T4
     *    / \
     *  T1   T2
	 * 
	 * @param y
	 * @return 返回旋转之后的平衡二叉树的根节点
	 */
	private Node rightRotate(Node y){
		Node x = y.left;
		Node T3 = x.right;
		
		// 右旋转操作
		x.right = y;
		y.left = T3;
		
		// 高度维护, 因为x节点的高度要依赖于y的高度, 所以要先计算y节点的高度
		y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
		x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
		
		return x;
	}

插入元素在不平衡节点的右侧的右侧(RR)

RR的情况需要对y节点进行左旋转操作

1539507217230

左旋转操作详解 :

  • 如下图所示, 节点大小存在如下关系 : T4 < y < T3 < x < T1 < z < T2
  • 让x节点的左孩子指向y节点
  • y节点的右孩子指向T3节点, 完成左旋转操作
    在这里插入图片描述

左旋转代码 :

	/**
	 * 对y节点进行左旋转操作
	 * 
     *           y                                   x
     *         /  \                              /       \
     *       T1    x      向左旋转 (y)          y         z
     *             / \   - - - - - - - ->     / \      /   \
     *           T2   z                      T1  T2   T3   T4
     *               / \
     *              T3 T4
	 * @param y
	 * @return 返回旋转之后的平衡二叉树的根节点
	 */
	private Node leftRotate(Node y){
		Node x = y.right;
		Node T3 = x.left;
		
		// 右旋转操作
		x.left = y;
		y.right = T3;
		
		// 高度维护, 因为x节点的高度要依赖于y的高度, 所以要先计算y节点的高度
		y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
		x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
		
		return x;
	}

插入节点在不平衡节点的左侧的右侧(LR)

  1. LR的情况需要先对x节点进行一次左旋转
  2. 再对y节点进行一次右旋转操作, 如下图所示 :

1539511247963

具体代码只要结合上面两中情况的左旋转, 右旋转操作即可实现, 伪码如下 :

	// 先对x左旋转		
	leftRotate(x);
	// 再对y右旋转
	rightRotate(y);

插入节点在不平衡节点的右侧的左侧(RL)

  1. RL的情况需要先对x节点进行一次右旋转操作

  2. 再对y节点进行一次左旋转操作, 如下图所示
    在这里插入图片描述具体代码只要结合上面两中情况的左旋转, 右旋转操作即可实现, 伪码如下 :

    	// 先对x右旋转		
	rightRotate(x);
	// 再对y左旋转
	leftRotate(y);

AVL树完整代码

package tree.avl ;

import java.util.ArrayList ;
import java.util.List ;

/**
 * 递归实现AVL平衡二叉树
 * 这里设计的树是不存储重复元素的, 重复添加元素只保存一个
 * @author 七夜雪
 *
 */
public class AVLTree<K extends Comparable<K>, V> {
	
	// 根节点
	private Node root ;
	// 树容量
	private int size ;
	
	public AVLTree() {
		this.root = null ;
		this.size = 0 ;
	}
	
	public boolean isEmpty() {
		return size == 0 ;
	}
	
	public int getSize(){
		return size;
	}
	
	/**
	 * 获取节点高度
	 * @param node
	 * @return
	 */
	private int getHeight(Node node){
		if (node == null) {
			return 0;
		}
		return node.height;
	}
	
	/**
	 * 获取节点平衡因子
	 * @param node
	 * @return
	 */
	private int getBalanceFactor(Node node){
		if (node == null) {
			return 0;
		}
		return getHeight(node.left) - getHeight(node.right);
	}
	
	/**
	 * 判断树是否符合二分搜索树的特点
	 * 根据二分搜索树的中序遍历具有顺序的特点来判断
	 * @return
	 */
	public boolean isBST(){
		List<K> keys = new ArrayList<>();
		inOrder(root, keys);
		for (int i = 1; i < keys.size(); i++) {
			if (keys.get(i - 1).compareTo(keys.get(i)) > 0) {
				return false;
			}
		}
		
		return  true;
	}
	
	/**
	 * 
	 * 中序遍历的递归方法, 深度优先
	 * 中序遍历指的是访问当前元素的顺序放在访问左右子节点之间
	 * 中序遍历的结果是有序的
	 * @param node
	 */
	private void inOrder(Node node, List<K> keys) {
		// 递归终止条件
		if (node == null) { 
			return ; 
		}
		
		// 1. 中序遍历访问左孩子
		inOrder(node.left, keys) ;
		// 2. 中序遍历先访问当前节点
		keys.add(node.key);
		// 3. 中序遍历访问右孩子
		inOrder(node.right, keys) ;
	}
	
	/**
	 * 判断是否为平衡二叉树
	 * @return
	 */
	public boolean isBalanced(){
		return isBalanced(root);
	}
	
	/**
	 *  判断node节点的平衡因子是否符合AVL树特性
	 *  递归方法
	 * @param node
	 * @return
	 */
	private boolean isBalanced(Node node){
		// 递归终止条件
		if (node == null) {
			return true;
		}
		
		// 获取节点平衡因子
		int balanceFactor = getBalanceFactor(node);
		// 节点平衡因子大于1时表示不再是AVL树
		if (Math.abs(balanceFactor) > 1) {
			System.out.println(node.key +  ":" + balanceFactor) ;
			return false;
		}
		
		return isBalanced(node.left) && isBalanced(node.right);
	}
	
	
	/**
	 * 向二分搜索树上添加节点
	 * @param e
	 */
	public void add(K key, V value) {
		root = add(root, key, value) ;
	}
	
	/**
	 * 向以node节点为根节点的树上添加节点e
	 * 递归方法
	 * @param node
	 * @param e
	 */
	private Node add(Node node, K key, V value) {
		// 递归终止条件
		if (node == null) {
			size++ ;
			return new Node(key, value) ;
		}
		
		// 添加的元素小于当前元素, 向左递归
		if (node.key.compareTo(key) > 0) {
			node.left = add(node.left, key, value) ;
			// 添加的元素小于当前元素, 向右递归
		} else if (node.key.compareTo(key) < 0) {
			node.right = add(node.right, key, value) ;
		} else {
			node.value = value;
		}
		
		// 更新节点高度
		node.height = Math.max(getHeight(node.left), getHeight(node.right)) + 1;
		
		// 计算平衡因子
		int balanceFactor = getBalanceFactor(node);
		
		// 平衡维护, 右旋转,  LL 
		if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {
			return rightRotate(node);
		}
		
		// 平衡维护, 左旋转,  RR
		if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0) {
			return leftRotate(node);
		}
		
		// 平衡维护, LR, 先左旋转转换成LL, 再右旋转
		if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {
			// LR的情况先对当前节点的左孩子进行左旋转
			node.left = leftRotate(node.left);
			// 再对当前节点进行右旋转
			return rightRotate(node);
		}
		
		// 平衡维护, RL, 先右旋转转换成RR, 再左旋转
		if (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {
			// RL的情况先对当前节点的右孩子进行右旋转
			node.right = rightRotate(node.right);
			// 再对当前节点进行左旋转
			return leftRotate(node);
		}
		
		return node ;
	}
	
	/**
	 * 对y节点进行右旋转操作
	 *          y                                      x
     *         / \                                   /    \
     *       x   T4     向右旋转 (y)                 z       y
     *      / \       - - - - - - - ->            / \     /  \
     *     z   T3                               T1   T2  T3   T4
     *    / \
     *  T1   T2
	 * 
	 * @param y
	 * @return 返回旋转之后的平衡二叉树的根节点
	 */
	private Node rightRotate(Node y){
		Node x = y.left;
		Node T3 = x.right;
		
		// 右旋转操作
		x.right = y;
		y.left = T3;
		
		// 高度维护, 因为x节点的高度要依赖于y的高度, 所以要先计算y节点的高度
		y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
		x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
		
		return x;
	}
	
	/**
	 * 对y节点进行左旋转操作
	 * 
     *           y                                      x
     *         /  \                                 /       \
     *       T1    x      向左旋转 (y)              y         z
     *             / \   - - - - - - - ->        / \      /   \
     *           T2   z                         T1 T2    T3   T4
     *                / \
     *               T3 T4
	 * @param y
	 * @return 返回旋转之后的平衡二叉树的根节点
	 */
	private Node leftRotate(Node y){
		Node x = y.right;
		Node T2 = x.left;
		
		// 右旋转操作
		x.left = y;
		y.right = T2;
		
		// 高度维护, 因为x节点的高度要依赖于y的高度, 所以要先计算y节点的高度
		y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
		x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
		
		return x;
	}
	
	/**
	 * 判断树中是否包含元素e
	 * @param e
	 * @return
	 */
	public boolean contains(K key) {
		return contains(root, key) ;
	}
	
	/**
	 * 判断树中是否包含元素e
	 * 递归方法
	 * @param node
	 * @param e
	 * @return
	 */
	private boolean contains(Node node, K key) {
		// 递归终结条件
		if (node == null) { 
			return false ; 
		}
		
		if (node.key.compareTo(key) == 0) {
			return true;
		} else if (node.key.compareTo(key) > 0) {
			return contains(node.left, key) ;
		} else { // node.e < e
			return contains(node.right, key) ;
		} 
		
	}
	
	/**
	 * 根据key值获取value
	 * @param key
	 * @return
	 */
	public V get(K key){
		return get(root, key);
	}
	
	/**
	 * 判断树中是否包含元素e
	 * 递归方法
	 * @param node
	 * @param e
	 * @return
	 */
	private V get(Node node, K key) {
		// 递归终结条件
		if (node == null) { 
			return null ; 
		}
		
		if (node.key.compareTo(key) == 0) {
			return node.value;
		} else if (node.key.compareTo(key) > 0) {
			return get(node.left, key) ;
		} else { // node.e < e
			return get(node.right, key) ;
		} 
		
	}
	
	
	/**
	 * 查找树中最小元素
	 * @return
	 */
	public K minimum(){
		if (size == 0) {
			throw new IllegalArgumentException("BSTree is empty");
		}
		return minimum(root).key;
	}
	
	/**
	 * 查找以node为根节点的最小元素, 递归方法
	 * @param node
	 * @return
	 */
	private Node minimum(Node node){
		if (node.left == null) {
			return node;
		}
		return minimum(node.left);
	}
	
	/**
	 * 查找树中最大元素
	 * @return
	 */
	public K maximum(){
		if (size == 0) {
			throw new IllegalArgumentException("BSTree is empty");
		}
		return maximum(root).key;
	}
	
	/**
	 * 查找以node为根节点的最大元素, 递归方法
	 * @param node
	 * @return
	 */
	private Node maximum(Node node){
		if (node.right == null) {
			return node;
		}
		return maximum(node.right);
	}
	
	
	/**
	 * 删除指定元素e所在的节点
	 * @param e
	 */
	public void remove(K key){
		root = remove(root, key);
	}
	
	/**
	 * 删除以node为根节点中的二分搜索树中
	 * @param node
	 * @param e
	 * @return 返回删除后的新二分搜索树的根节点
	 */
	private Node remove(Node node, K key){
		if (node == null) {
			return null;
		}
		
		Node retNode;
		// node.e > e
		if (node.key.compareTo(key) > 0) {
			node.left =remove(node.left, key);
			retNode = node;
		// node.e < e	
		} else if (node.key.compareTo(key) < 0) {
			node.right = remove(node.right, key);
			retNode = node;
		} else { // e == node.e
			// 待删除节点左子树为空的情况
			if (node.left == null) {
				Node rightNode = node.right;
				node.right = null;
				size --;
				retNode = rightNode;
			// 待删除节点右子树为空的情况
			} else if (node.right == null) {
				Node leftNode = node.left;
				node.left = null;
				size --;
				retNode = leftNode;
			// 待删除节点左右子树均不为空的情况
			} else {
				// 查找待删除节点的后继节点
				// 用后继节点替换当前待删除节点
				
				// 查找后继节点, 从待删除节点的右子树,查找最小值
				Node successor = minimum(node.right);
				// 这个时候要删除的节点的key和successor的key是相等的
				successor.right = remove(node.right, successor.key);
				successor.left = node.left;
				// 后继节点完成替换, 删除当前节点
				node.left = node.right = null;
				retNode = successor;
			}
		}
		
		if (retNode == null) {
			return null;
		}
		
		/**********************平衡维护操作******************************/
		// 更新节点高度
		retNode.height = Math.max(getHeight(retNode.left), getHeight(retNode.right)) + 1;
		
		// 计算平衡因子
		int balanceFactor = getBalanceFactor(retNode);
		
		// 平衡维护, 右旋转,  LL 
		if (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0) {
			return rightRotate(retNode);
		}
		
		// 平衡维护, 左旋转,  RR
		if (balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0) {
			return leftRotate(retNode);
		}
		
		// 平衡维护, LR, 先左旋转转换成LL, 再右旋转
		if (balanceFactor > 1 && getBalanceFactor(retNode.left) < 0) {
			// LR的情况先对当前节点的左孩子进行左旋转
			node.left = leftRotate(retNode.left);
			// 再对当前节点进行右旋转
			return rightRotate(retNode);
		}
		
		// 平衡维护, RL, 先右旋转转换成RR, 再左旋转
		if (balanceFactor < -1 && getBalanceFactor(retNode.right) > 0) {
			// RL的情况先对当前节点的右孩子进行右旋转
			node.right = rightRotate(retNode.right);
			// 再对当前节点进行左旋转
			return leftRotate(retNode);
		}
		/**********************平衡维护操作******************************/
		
		return retNode;
	}
	
	
	@Override
	public String toString() {
		StringBuilder res = new StringBuilder();
		generateString(root, 0, res);
		return res.toString();
	}
	
	/**
	 * 生成以node为根节点，深度为depth的描述二叉树的字符串
	 * @param node 根节点
	 * @param depth 深度
	 * @param res 用于拼接字符串的StringBuilder
	 * @return
	 */
	private void generateString(Node node, int depth, StringBuilder res){
		if (node == null) {
			res.append(generateDepthString(depth) + "null\n");
            return; 
		}
		res.append(generateDepthString(depth)).append(node.key + "\n");
		generateString(node.left, depth + 1, res);
		generateString(node.right, depth + 1, res);
	}

	private StringBuilder generateDepthString(int depth){
		StringBuilder res = new StringBuilder();
		for (int i = 0; i < depth; i++) {
			res.append("--");
		}
		return res;
	}

	/**
	 * 二分搜索树节点类
	 * @author 七夜雪
	 *
	 */
	private class Node {
		public K key ;
		public V value;
		// 左右子树
		public Node	left , right ;
		public int height;
		
		public Node(K key, V value) {
			this.key = key ;
			this.value = value ;
			// 叶子节点高度默认为1
			this.height = 1;
			this.left = null ;
			this.right = null ;
		}
	}
}

测试代码

这里使用了一个FileOperation工具类, 读取一个文本中的单词, 放入一个list中

	@Test
	public void testAVLAdd() {
		System.out.println("Pride and Prejudice") ;
		URL resource = this.getClass().getClassLoader().getResource("pride-and-prejudice.txt");
		ArrayList<String> words = new ArrayList<>() ;
		if (FileOperation.readFile(resource.getPath() , words)) {
			AVLTree<String, Integer> avlMap = new AVLTree<>();
			for (String word : words){
				avlMap.add(word, 0);
			}
			
			// isBST(), 辅助函数, 判断树是否符合二分搜索树特性
			System.out.println("AVL Tree is BST: " + avlMap.isBST()) ;
			// isBalanced(), 辅助函数, 判断树是否符合AVL树特性
			System.out.println("AVL Tree is isBalanced: " + avlMap.isBalanced()) ;
			
			// 删除操作
			for (String word : words){
				avlMap.remove(word);
				// 如果元素删除之后存在不符合二分搜索树或平衡二叉树的特性, 就打印错误日志
				if (!(avlMap.isBST() && avlMap.isBalanced())) {
					System.err.println("Error") ;
				}
			}
			
			// isBST(), 辅助函数, 判断树是否符合二分搜索树特性
			System.out.println("AVL Tree is BST: " + avlMap.isBST()) ;
			// isBalanced(), 辅助函数, 判断树是否符合AVL树特性
			System.out.println("AVL Tree is isBalanced: " + avlMap.isBalanced()) ;
		}

慕课网<玩转数据结构>学习笔记
完整代码参加github : https://github.com/564660143/DataStructuresAndAlgorithms.git

七夜丶雪
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡二叉树（AVL树）
Ronz 的博客
01-24 6985
一、平衡二叉树概述 1.1 什么是平衡二叉树 平衡二叉树也叫 AVL 树。平衡二叉树是具有以下特点的二叉查找树：它是一棵空树或它的左右两个子树的高度差的绝对值不超过 1， 并且左右两个子树都是一棵平衡二叉树。 图一 平衡二叉树 图二 非平衡二叉树 1.2 为什么要有平衡二叉树 在上一篇文章 二叉排序树 中对二叉排序树做了介
平衡二叉树（AVL树）深入解读
Zxn、Sirius荣耀之路
08-06 1万+
平衡二叉树又称AVL树性质：它或者是颗空树，或者是具有下列性质的二叉树： 它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。 若将二叉树节点的平衡因子BF定义为该节点的左子树的深度减去它的右子树的深度，则平衡二叉树上所有节点的平衡因子只可能为-1,0,1. 只要二叉树上有一个节点的平衡因子的绝对值大于1，那么这颗平衡二叉树就失去了平衡。 根据上述性质我们可以发现图（
详解AVL树（平衡二叉树）
热门推荐
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
手把手教你实现AVL树、平衡二叉树
weixin_61857742的博客
04-07 1369
今天，小编带大家一起来学习平衡二叉树（AVL树）吧。以下就简称AVL树了。 想必能点开这篇博客的朋友都是极度深爱计算机的，那今天就让我们一起揭开AVL树的神秘面纱吧！ 目录 一.基本概念 二.实现原理 （一）插入左子树 ①插入左子节点 ②插入右子节点 （二）插入右子树 ①插入右子节点 ②插入左子节点 （三）左旋转 （四）右旋转 三.代码实现 一.基本概念 AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis。 AVL树是搜索二叉树的一
平衡二叉树（AVL）
lucyLee的博客
09-05 1万+
1. 概述 1.1 定义 平衡二叉树，全称为平衡二叉搜索树 它是由苏联数学家Adelson-Velsky 和 Landis提出来的，因此平衡二叉树又叫AVL树 平衡二叉树的定义是一种递归定义，要求每个节点都具有以下特性： 可以是一棵空树 左子树和右子树高度之差的绝对值不超过1（左右子树的高度差可以为0、1和 -1） 左子树和右子树均为平衡二叉树 为什么平衡二叉树是二叉搜索树？ 之前，在学习二叉搜索树时，增删该查的效率最坏为O(n)O(n)O(n)。此时，二叉树退化成一条链 若二叉搜索树尽可能的平衡
平衡二叉树（AVL）的实现(详细) c++ 二叉排序树
Tree_sea的博客
07-31 2988
平衡二叉树概念 平衡二叉排序树（Balanced Binary Tree），因由前苏联数学家Adelson-Velskii 和 Landis于1962年首先提出的，所以又称为AVL树。 平衡二叉树是一种特殊的二叉排序树，理解平衡二叉树首先要理解什么是二叉排序树。 如果已经了解二叉排序树可以直接看下面平衡二叉树内容。 二叉排序树（Binary Sort Tree） 所谓二叉排序树(BST)即： （1）若该树的左子树不为空，那么左子树所以结点的值均小于其根结点的值。 （2）若该树的右子树不为空，那么右子树所
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
主要介绍了C语言数据结构之平衡二叉树（AVL树）实现方法,结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧,需要的朋友可以参考下
03平衡二叉树_AVLTree.rar_03平衡二叉树_AVLTree_大话数据结构_平衡二叉树
09-21
查找算法，平衡二叉树，大话数据结构里面的。
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
平衡二叉树(AVL树)
Baron_ND的博客
12-27 982
简介 平衡二叉树，又称为AVL树，为了优化排序二叉树极端情况（从小到大或从大到小插入，呈现链状）而衍生出来的结构 特点 1.基于排序二叉树 2.任意节点的左右子树的高度差都小于2 因此，同排序二叉树一样，平衡二叉树只需要在插入和删除时，进行平衡，使得左右子树高度差均小于1即可 查询 所有二叉排序树的查询过程都是一致的，包括平衡二叉树和红黑树，都是通过二分法向下查询，可以参考二叉排序树的查询 节点基本数据结构 typedef struct TreeNode { int data;
什么是平衡二叉树（AVL）
墨鱼菜鸡
09-09 324
前言 Wiki:在 计算机科学中， AVL树是最早被发明的 自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为 高度平衡树。查找、插入和删除在平均和最坏情况下的 时间复杂度都是{\displaystyle O(\log {n})} 。增加和删除元素的操作则可能需要借由一次或...
平衡二叉树(AVL)
优雅永不过时
07-23 2808
上图BST存在的问题分析： 左子树全部为空，从形式上看，更像是一个单链表 插入速度没有影响 查询速度明显降低(因为需要依次比较)，不能发挥BST的优势，因此每次还需要比较左子树，其查询速度比单链表还慢 解决方案平衡二叉树 平衡二叉树 1.平衡二叉树也叫平衡二叉搜索树，又被称为AVL树，可以保证查询效率较高 2.具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过一，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、avl、替罪羊树、Treap、伸展树等 3.举例说明，.
AVL树 算法思想与代码实现
weixin_30666753的博客
07-07 112
AVL树是高度平衡的二叉搜索树，按照二叉搜索树（Binary Search Tree）的性质，AVL首先要满足： 若它的左子树不为空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不为空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。 AVL树的性质： 左子树和右子树的高度之差的绝对值不超过1 树中的每个左子树和右子树都是AVL树...
12-玩转数据结构-AVL
weixin_33872566的博客
08-16 128
回到二分搜索树内容，更加高级的话题，平衡二叉树。 我们之前实现的那个二叉树在最差情况下会退化成链表，在现有二分搜索树基础上添加一定的机制，使得二分搜索树可以维持平衡二叉树性质。AVL树就是一种经典的平衡二叉树。 两个发明人首字母缩写: G. M. Adelson-Velsky和 E.M.Landis 1962...
平衡二叉树的构造c语言,数据结构之---C语言实现平衡二叉树（AVL树）
最新发布
06-02
下面是C语言实现平衡二叉树（AVL树）的代码： ``` #include #include /* 定义平衡二叉树节点结构体 */ struct AVLNode { int data; // 存储的数据 int height; // 节点高度 struct AVLNode *leftChild; // 左...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值